home *** CD-ROM | disk | FTP | other *** search
/ Apple WWDC 1996 / WWDC96_1996 (CD).toast / Technology Materials / MacOS 8 Resources / Developer Tools / Mac OS 8 Interfaces & Libraries / Interfaces / PInterfaces / OCEMessaging.p < prev    next >
Text File  |  1996-05-01  |  30KB  |  1,160 lines
  1. {
  2.      File:        OCEMessaging.p
  3.  
  4.      Contains:    Apple Open Collaboration Environment Messaging Interfaces.
  5.  
  6.      Version:    Technology:    AOCE Toolbox 1.02
  7.                  Release:    Universal Interfaces 3.0d3 on Copland DR1
  8.  
  9.      Copyright:    © 1984-1996 by Apple Computer, Inc.  All rights reserved.
  10.  
  11.      Bugs?:        If you find a problem with this file, send the file and version
  12.                  information (from above) and the problem description to:
  13.  
  14.                      Internet:    apple.bugs@applelink.apple.com
  15.                      AppleLink:    APPLE.BUGS
  16.  
  17. }
  18. {$IFC UNDEFINED UsingIncludes}
  19. {$SETC UsingIncludes := 0}
  20. {$ENDC}
  21.  
  22. {$IFC NOT UsingIncludes}
  23.  UNIT OCEMessaging;
  24.  INTERFACE
  25. {$ENDC}
  26.  
  27. {$IFC UNDEFINED __OCEMESSAGING__}
  28. {$SETC __OCEMESSAGING__ := 1}
  29.  
  30. {$I+}
  31. {$SETC OCEMessagingIncludes := UsingIncludes}
  32. {$SETC UsingIncludes := 1}
  33.  
  34. {$IFC UNDEFINED __FILES__}
  35. {$I Files.p}
  36. {$ENDC}
  37. {$IFC UNDEFINED __TYPES__}
  38. {$I Types.p}
  39. {$ENDC}
  40. {$IFC UNDEFINED __DIGITALSIGNATURE__}
  41. {$I DigitalSignature.p}
  42. {$ENDC}
  43. {$IFC UNDEFINED __OCE__}
  44. {$I OCE.p}
  45. {$ENDC}
  46. {$IFC UNDEFINED __OCEAUTHDIR__}
  47. {$I OCEAuthDir.p}
  48. {$ENDC}
  49.  
  50. {$PUSH}
  51. {$ALIGN MAC68K}
  52. {$LibExport+}
  53.  
  54. {$IFC FOR_SYSTEM7_ONLY }
  55. { **************************************************************************** }
  56. {
  57.  Definitions common to OCEMessaging and to OCEMail. These relate to addressing,
  58. message ids and priorities, etc. 
  59. }
  60. {  Values of IPMPriority  }
  61.  
  62. CONST
  63.     kIPMAnyPriority                = 0;                            {  FOR FILTER ONLY  }
  64.     kIPMNormalPriority            = 1;
  65.     kIPMLowPriority                = 2;
  66.     kIPMHighPriority            = 3;
  67.  
  68.  
  69. TYPE
  70.     IPMPriority                            = Byte;
  71. {  Values of IPMAccessMode  }
  72.  
  73. CONST
  74.     kIPMAtMark                    = 0;
  75.     kIPMFromStart                = 1;
  76.     kIPMFromLEOM                = 2;
  77.     kIPMFromMark                = 3;
  78.  
  79.  
  80. TYPE
  81.     IPMAccessMode                        = INTEGER;
  82.  
  83. CONST
  84.     kIPMUpdateMsgBit            = 4;
  85.     kIPMNewMsgBit                = 5;
  86.     kIPMDeleteMsgBit            = 6;
  87.  
  88. {  Values of IPMNotificationType  }
  89.     kIPMUpdateMsgMask            = $10;
  90.     kIPMNewMsgMask                = $20;
  91.     kIPMDeleteMsgMask            = $40;
  92.  
  93.  
  94. TYPE
  95.     IPMNotificationType                    = Byte;
  96. {  Values of IPMSenderTag  }
  97.  
  98. CONST
  99.     kIPMSenderRStringTag        = 0;
  100.     kIPMSenderRecordIDTag        = 1;
  101.  
  102.  
  103. TYPE
  104.     IPMSenderTag                        = INTEGER;
  105.  
  106. CONST
  107.     kIPMFromDistListBit            = 0;
  108.     kIPMDummyRecBit                = 1;
  109.     kIPMFeedbackRecBit            = 2;                            {  should be redirected to feedback queue  }
  110.     kIPMReporterRecBit            = 3;                            {  should be redirected to reporter original queue  }
  111.     kIPMBCCRecBit                = 4;                            {  this recipient is blind to all recipients of message  }
  112.  
  113. {  Values of OCERecipientOffsetFlags  }
  114.     kIPMFromDistListMask        = $01;
  115.     kIPMDummyRecMask            = $02;
  116.     kIPMFeedbackRecMask            = $04;
  117.     kIPMReporterRecMask            = $08;
  118.     kIPMBCCRecMask                = $10;
  119.  
  120.  
  121. TYPE
  122.     OCERecipientOffsetFlags                = Byte;
  123.     OCECreatorTypePtr = ^OCECreatorType;
  124.     OCECreatorType = RECORD
  125.         msgCreator:                OSType;
  126.         msgType:                OSType;
  127.     END;
  128.  
  129.  
  130. CONST
  131.     kIPMTypeWildCard            = 'ipmw';
  132.     kIPMFamilyUnspecified        = 0;
  133.     kIPMFamilyWildCard            = $3F3F3F3F;                    {  '????' * well known signature  }
  134.     kIPMSignature                = 'ipms';                        {  base type * well known message types  }
  135.     kIPMReportNotify            = 'rptn';                        {  routing feedback * well known message block types  }
  136.     kIPMEnclosedMsgType            = 'emsg';                        {  enclosed (nested) message  }
  137.     kIPMReportInfo                = 'rpti';                        {  recipient information  }
  138.     kIPMDigitalSignature        = 'dsig';                        {  digital signature  }
  139.  
  140. {  Values of IPMMsgFormat  }
  141.     kIPMOSFormatType            = 1;
  142.     kIPMStringFormatType        = 2;
  143.  
  144.  
  145. TYPE
  146.     IPMMsgFormat                        = INTEGER;
  147.     IPMStringMsgType                    = Str32;
  148.     TheTypePtr = ^TheType;
  149.     TheType = RECORD
  150.         CASE INTEGER OF
  151.         0: (
  152.             msgOSType:            OCECreatorType;
  153.             );
  154.         1: (
  155.             msgStrType:            IPMStringMsgType;
  156.             );
  157.     END;
  158.  
  159.     IPMMsgTypePtr = ^IPMMsgType;
  160.     IPMMsgType = RECORD
  161.         format:                    IPMMsgFormat;                            {  IPMMsgFormat }
  162.         theType:                TheType;
  163.     END;
  164.  
  165. {
  166. Following are the known extension values for IPM addresses handled by Apple.
  167. We define the definition of the entn extension below.
  168. }
  169.  
  170. CONST
  171.     kOCEalanXtn                    = 'alan';
  172.     kOCEentnXtn                    = 'entn';                        {  entn = entity name (aka DSSpec)  }
  173.     kOCEaphnXtn                    = 'aphn';
  174.  
  175. {
  176. Following are the specific definitions for the extension for the standard
  177. OCEMail 'entn' addresses.  [Note, the actual extension is formatted as in
  178. IPMEntityNameExtension.]
  179. }
  180. {  entn extension forms  }
  181.     kOCEAddrXtn                    = 'addr';
  182.     kOCEQnamXtn                    = 'qnam';
  183.     kOCEAttrXtn                    = 'attr';                        {  an attribute specification  }
  184.     kOCESpAtXtn                    = 'spat';                        {  specific attribute  }
  185.  
  186. {
  187. Following are the specific definitions for standard
  188. OCEMail 'aphn' extension value.  
  189.  
  190. All RStrings here are packed (e.g. truncated to length) and even padded (e.g.
  191. if length odd, then a pad byte (zero) should be introduced before the next field).
  192.  
  193. The extension value is in the packed form of the following structure:
  194.     RString        phoneNumber;
  195.     RString        modemType;
  196.     Str32        queueuName;
  197.  
  198. The body of phoneNumber compound RString is in the packed form of the following structure:
  199.     short         subType;
  200.     RString     countryCode;                // used when subType == kOCEUseHandyDial
  201.     RString        areaCode;                    // used when subType == kOCEUseHandyDial
  202.     RString        phone;                        // used when subType == kOCEUseHandyDial
  203.     RString        postFix;                    // used when subType == kOCEUseHandyDial
  204.     RString        nonHandyDialString;            // used when subType == kOCEDontUseHandyDial
  205. }
  206. {  phoneNumber sub type constants  }
  207.     kOCEUseHandyDial            = 1;
  208.     kOCEDontUseHandyDial        = 2;
  209.  
  210. {  FORMAT OF A PACKED FORM RECIPIENT  }
  211.  
  212. TYPE
  213.     ProtoOCEPackedRecipientPtr = ^ProtoOCEPackedRecipient;
  214.     ProtoOCEPackedRecipient = RECORD
  215.         dataLength:                INTEGER;
  216.     END;
  217.  
  218.  
  219. CONST
  220.     kOCEPackedRecipientMaxBytes    = 4094;
  221.  
  222.  
  223. TYPE
  224.     OCEPackedRecipientPtr = ^OCEPackedRecipient;
  225.     OCEPackedRecipient = RECORD
  226.         dataLength:                INTEGER;
  227.         data:                    PACKED ARRAY [0..4093] OF Byte;
  228.     END;
  229.  
  230.     IPMEntnQueueExtensionPtr = ^IPMEntnQueueExtension;
  231.     IPMEntnQueueExtension = RECORD
  232.         queueName:                Str32;
  233.     END;
  234.  
  235. {  kOCEAttrXtn  }
  236.     IPMEntnAttributeExtensionPtr = ^IPMEntnAttributeExtension;
  237.     IPMEntnAttributeExtension = RECORD
  238.         attributeName:            AttributeType;
  239.     END;
  240.  
  241. {  kOCESpAtXtn  }
  242.     IPMEntnSpecificAttributeExtensionPtr = ^IPMEntnSpecificAttributeExtension;
  243.     IPMEntnSpecificAttributeExtension = RECORD
  244.         attributeCreationID:    AttributeCreationID;
  245.         attributeName:            AttributeType;
  246.     END;
  247.  
  248. {  All IPM entn extensions fit within the following  }
  249.     IPMEntityNameExtensionPtr = ^IPMEntityNameExtension;
  250.     IPMEntityNameExtension = RECORD
  251.         subExtensionType:        OSType;
  252.         CASE INTEGER OF
  253.         0: (
  254.             specificAttribute:    IPMEntnSpecificAttributeExtension;
  255.             );
  256.         1: (
  257.             attribute:            IPMEntnAttributeExtension;
  258.             );
  259.         2: (
  260.             queue:                IPMEntnQueueExtension;
  261.             );
  262.     END;
  263.  
  264. {  addresses with kIPMNBPXtn should specify this nbp type  }
  265.     IPMMsgIDPtr = ^IPMMsgID;
  266.     IPMMsgID = RECORD
  267.         id:                        ARRAY [0..3] OF LONGINT;
  268.     END;
  269.  
  270. {  Values of IPMHeaderSelector  }
  271.  
  272. CONST
  273.     kIPMTOC                        = 0;
  274.     kIPMSender                    = 1;
  275.     kIPMProcessHint                = 2;
  276.     kIPMMessageTitle            = 3;
  277.     kIPMMessageType                = 4;
  278.     kIPMFixedInfo                = 7;
  279.  
  280.  
  281. TYPE
  282.     IPMHeaderSelector                    = Byte;
  283.     TheSenderPtr = ^TheSender;
  284.     TheSender = RECORD
  285.         CASE INTEGER OF
  286.         0: (
  287.             rString:            RString;
  288.             );
  289.         1: (
  290.             rid:                PackedRecordID;
  291.             );
  292.     END;
  293.  
  294.     IPMSenderPtr = ^IPMSender;
  295.     IPMSender = RECORD
  296.         sendTag:                IPMSenderTag;
  297.         theSender:                TheSender;
  298.     END;
  299.  
  300. { **************************************************************************** }
  301. {  Definitions specific to OCEMessaging  }
  302.     IPMContextRef                        = LONGINT;
  303.     IPMQueueRef                            = LONGINT;
  304.     IPMMsgRef                            = LONGINT;
  305.     IPMSeqNum                            = LONGINT;
  306.     IPMProcHint                            = Str32;
  307.     IPMQueueName                        = Str32;
  308.     IPMNoteProcPtr = ProcPtr;  { PROCEDURE IPMNote(queue: IPMQueueRef; seqNum: IPMSeqNum; notificationType: ByteParameter; userData: LONGINT); }
  309.  
  310.     IPMNoteUPP = UniversalProcPtr;
  311.  
  312. CONST
  313.     uppIPMNoteProcInfo = $000037C0;
  314.  
  315. FUNCTION NewIPMNoteProc(userRoutine: IPMNoteProcPtr): IPMNoteUPP;
  316.     {$IFC NOT GENERATINGCFM }
  317.     INLINE $2E9F;
  318.     {$ENDC}
  319.  
  320. PROCEDURE CallIPMNoteProc(queue: IPMQueueRef; seqNum: IPMSeqNum; notificationType: ByteParameter; userData: LONGINT; userRoutine: IPMNoteUPP);
  321.     {$IFC NOT GENERATINGCFM}
  322.     INLINE $205F, $4E90;
  323.     {$ENDC}
  324.  
  325. TYPE
  326.     IPMFixedHdrInfoPtr = ^IPMFixedHdrInfo;
  327.     IPMFixedHdrInfo = RECORD
  328.         version:                INTEGER;
  329.         authenticated:            BOOLEAN;
  330.         signatureEnclosed:        BOOLEAN;                                {   digital signature enclosed  }
  331.         msgSize:                LONGINT;
  332.         notification:            SInt8;
  333.         priority:                SInt8;
  334.         blockCount:                INTEGER;
  335.         originalRcptCount:        INTEGER;                                {         original number of recipients  }
  336.         refCon:                    LONGINT;                                {         Client defined data  }
  337.         reserved:                INTEGER;
  338.         creationTime:            UTCTime;                                {         Time when it was created  }
  339.         msgID:                    IPMMsgID;
  340.         family:                    OSType;                                    {  family this msg belongs (e.g. mail)  }
  341.     END;
  342.  
  343.  
  344. CONST
  345.     kIPMDeliveryNotificationBit    = 0;
  346.     kIPMNonDeliveryNotificationBit = 1;
  347.     kIPMEncloseOriginalBit        = 2;
  348.     kIPMSummaryReportBit        = 3;                            {  modify enclose original to only on error  }
  349.     kIPMOriginalOnlyOnErrorBit    = 4;
  350.  
  351.     kIPMNoNotificationMask        = $00;
  352.     kIPMDeliveryNotificationMask = $01;
  353.     kIPMNonDeliveryNotificationMask = $02;
  354.     kIPMDontEncloseOriginalMask    = $00;
  355.     kIPMEncloseOriginalMask        = $04;
  356.     kIPMImmediateReportMask        = $00;
  357.     kIPMSummaryReportMask        = $08;
  358.     kIPMOriginalOnlyOnErrorMask    = $10;
  359.     kIPMEncloseOriginalOnErrorMask = $14;
  360.  
  361. {  standard Non delivery codes  }
  362.     kIPMNoSuchRecipient            = $0001;
  363.     kIPMRecipientMalformed        = $0002;
  364.     kIPMRecipientAmbiguous        = $0003;
  365.     kIPMRecipientAccessDenied    = $0004;
  366.     kIPMGroupExpansionProblem    = $0005;
  367.     kIPMMsgUnreadable            = $0006;
  368.     kIPMMsgExpired                = $0007;
  369.     kIPMMsgNoTranslatableContent = $0008;
  370.     kIPMRecipientReqStdCont        = $0009;
  371.     kIPMRecipientReqSnapShot    = $000A;
  372.     kIPMNoTransferDiskFull        = $000B;
  373.     kIPMNoTransferMsgRejectedbyDest = $000C;
  374.     kIPMNoTransferMsgTooLarge    = $000D;
  375.  
  376. { *********************************************************************** }
  377. {
  378. This is the structure that will be returned by enumerate and getmsginfo
  379. This definition is just to give you a template, the position of msgType
  380. is variable since this is a packed structure.  procHint and msgType are
  381. packed and even length padded.
  382.  
  383. * master message info 
  384. }
  385.  
  386. TYPE
  387.     IPMMsgInfoPtr = ^IPMMsgInfo;
  388.     IPMMsgInfo = RECORD
  389.         sequenceNum:            IPMSeqNum;
  390.         userData:                LONGINT;
  391.         respIndex:                INTEGER;
  392.         padByte:                SInt8;
  393.         priority:                SInt8;
  394.         msgSize:                LONGINT;
  395.         originalRcptCount:        INTEGER;
  396.         reserved:                INTEGER;
  397.         creationTime:            UTCTime;
  398.         msgID:                    IPMMsgID;
  399.         family:                    OSType;                                    {  family this msg belongs (e.g. mail)  }
  400.         procHint:                IPMProcHint;
  401.         filler2:                SInt8;
  402.         msgType:                IPMMsgType;
  403.     END;
  404.  
  405.     IPMBlockType                        = OCECreatorType;
  406.     IPMBlockTypePtr                     = ^IPMBlockType;
  407.     IPMTOCPtr = ^IPMTOC;
  408.     IPMTOC = RECORD
  409.         blockType:                IPMBlockType;
  410.         blockOffset:            LONGINT;
  411.         blockSize:                LONGINT;
  412.         blockRefCon:            LONGINT;
  413.     END;
  414.  
  415. {
  416. The following structure is just to describe the layout of the SingleFilter.
  417. Each field should be packed and word aligned when passed to the IPM ToolBox.
  418. }
  419.     IPMSingleFilterPtr = ^IPMSingleFilter;
  420.     IPMSingleFilter = RECORD
  421.         priority:                SInt8;
  422.         padByte:                SInt8;
  423.         family:                    OSType;                                    {  family this msg belongs (e.g. mail), '????' for all  }
  424.         script:                    ScriptCode;                                {  Language Identifier  }
  425.         hint:                    IPMProcHint;
  426.         filler2:                SInt8;
  427.         msgType:                IPMMsgType;
  428.     END;
  429.  
  430.     IPMFilterPtr = ^IPMFilter;
  431.     IPMFilter = RECORD
  432.         count:                    INTEGER;
  433.         sFilters:                ARRAY [0..0] OF IPMSingleFilter;
  434.     END;
  435.  
  436. {
  437. ************************************************************************
  438. Following structures define the ``start'' of a recipient report block and the
  439. elements of the array respectively.
  440. }
  441.     IPMReportBlockHeaderPtr = ^IPMReportBlockHeader;
  442.     IPMReportBlockHeader = RECORD
  443.         msgID:                    IPMMsgID;                                {  message id of the original  }
  444.         creationTime:            UTCTime;                                {  creation time of the report  }
  445.     END;
  446.  
  447.     OCERecipientReportPtr = ^OCERecipientReport;
  448.     OCERecipientReport = RECORD
  449.         rcptIndex:                INTEGER;                                {  index of recipient in original message  }
  450.         result:                    OSErr;                                    {  result of sending letter to this recipient }
  451.     END;
  452.  
  453. { *********************************************************************** }
  454.     IPMParamBlockPtr = ^IPMParamBlock;
  455.     IPMIOCompletionProcPtr = Register68kProcPtr;  { PROCEDURE IPMIOCompletion(paramBlock: IPMParamBlockPtr); }
  456.  
  457.     IPMIOCompletionUPP = UniversalProcPtr;
  458.     IPMOpenContextPBPtr = ^IPMOpenContextPB;
  459.     IPMOpenContextPB = RECORD
  460.         qLink:                    Ptr;
  461.         reservedH1:                LONGINT;
  462.         reservedH2:                LONGINT;
  463.         ioCompletion:            IPMIOCompletionUPP;
  464.         ioResult:                OSErr;
  465.         saveA5:                    LONGINT;
  466.         reqCode:                INTEGER;
  467.         contextRef:                IPMContextRef;                            {  <--  Context reference to be used in further calls }
  468.     END;
  469.  
  470.     IPMCloseContextPB                    = IPMOpenContextPB;
  471.     IPMCloseContextPBPtr                 = ^IPMCloseContextPB;
  472.     IPMCreateQueuePBPtr = ^IPMCreateQueuePB;
  473.     IPMCreateQueuePB = RECORD
  474.         qLink:                    Ptr;
  475.         reservedH1:                LONGINT;
  476.         reservedH2:                LONGINT;
  477.         ioCompletion:            IPMIOCompletionUPP;
  478.         ioResult:                OSErr;
  479.         saveA5:                    LONGINT;
  480.         reqCode:                INTEGER;
  481.         filler1:                LONGINT;
  482.         queue:                    OCERecipientPtr;
  483.         identity:                AuthIdentity;                            {  used only if queue is remote  }
  484.         owner:                    PackedRecordIDPtr;                        {  used only if queue is remote  }
  485.     END;
  486.  
  487. {  For createqueue and deletequeue only queue and identity are used  }
  488.     IPMDeleteQueuePB                    = IPMCreateQueuePB;
  489.     IPMDeleteQueuePBPtr                 = ^IPMDeleteQueuePB;
  490.     IPMOpenQueuePBPtr = ^IPMOpenQueuePB;
  491.     IPMOpenQueuePB = RECORD
  492.         qLink:                    Ptr;
  493.         reservedH1:                LONGINT;
  494.         reservedH2:                LONGINT;
  495.         ioCompletion:            IPMIOCompletionUPP;
  496.         ioResult:                OSErr;
  497.         saveA5:                    LONGINT;
  498.         reqCode:                INTEGER;
  499.         contextRef:                IPMContextRef;
  500.         queue:                    OCERecipientPtr;
  501.         identity:                AuthIdentity;
  502.         filter:                    IPMFilterPtr;
  503.         newQueueRef:            IPMQueueRef;
  504.         notificationProc:        IPMNoteUPP;
  505.         userData:                LONGINT;
  506.         noteType:                SInt8;
  507.         padByte:                SInt8;
  508.         reserved:                LONGINT;
  509.         reserved2:                LONGINT;
  510.     END;
  511.  
  512.     IPMCloseQueuePBPtr = ^IPMCloseQueuePB;
  513.     IPMCloseQueuePB = RECORD
  514.         qLink:                    Ptr;
  515.         reservedH1:                LONGINT;
  516.         reservedH2:                LONGINT;
  517.         ioCompletion:            IPMIOCompletionUPP;
  518.         ioResult:                OSErr;
  519.         saveA5:                    LONGINT;
  520.         reqCode:                INTEGER;
  521.         queueRef:                IPMQueueRef;
  522.     END;
  523.  
  524.     IPMEnumerateQueuePBPtr = ^IPMEnumerateQueuePB;
  525.     IPMEnumerateQueuePB = RECORD
  526.         qLink:                    Ptr;
  527.         reservedH1:                LONGINT;
  528.         reservedH2:                LONGINT;
  529.         ioCompletion:            IPMIOCompletionUPP;
  530.         ioResult:                OSErr;
  531.         saveA5:                    LONGINT;
  532.         reqCode:                INTEGER;
  533.         queueRef:                IPMQueueRef;
  534.         startSeqNum:            IPMSeqNum;
  535.         getProcHint:            BOOLEAN;
  536.         getMsgType:                BOOLEAN;
  537.         filler:                    INTEGER;
  538.         filter:                    IPMFilterPtr;
  539.         numToGet:                INTEGER;
  540.         numGotten:                INTEGER;
  541.         enumCount:                LONGINT;
  542.         enumBuffer:                Ptr;                                    {  will be packed array of IPMMsgInfo  }
  543.         actEnumCount:            LONGINT;
  544.     END;
  545.  
  546.     IPMChangeQueueFilterPB                = IPMEnumerateQueuePB;
  547.     IPMChangeQueueFilterPBPtr             = ^IPMChangeQueueFilterPB;
  548.     IPMDeleteMsgRangePBPtr = ^IPMDeleteMsgRangePB;
  549.     IPMDeleteMsgRangePB = RECORD
  550.         qLink:                    Ptr;
  551.         reservedH1:                LONGINT;
  552.         reservedH2:                LONGINT;
  553.         ioCompletion:            IPMIOCompletionUPP;
  554.         ioResult:                OSErr;
  555.         saveA5:                    LONGINT;
  556.         reqCode:                INTEGER;
  557.         queueRef:                IPMQueueRef;
  558.         startSeqNum:            IPMSeqNum;
  559.         endSeqNum:                IPMSeqNum;
  560.         lastSeqNum:                IPMSeqNum;
  561.     END;
  562.  
  563.     IPMOpenMsgPBPtr = ^IPMOpenMsgPB;
  564.     IPMOpenMsgPB = RECORD
  565.         qLink:                    Ptr;
  566.         reservedH1:                LONGINT;
  567.         reservedH2:                LONGINT;
  568.         ioCompletion:            IPMIOCompletionUPP;
  569.         ioResult:                OSErr;
  570.         saveA5:                    LONGINT;
  571.         reqCode:                INTEGER;
  572.         queueRef:                IPMQueueRef;
  573.         sequenceNum:            IPMSeqNum;
  574.         newMsgRef:                IPMMsgRef;
  575.         actualSeqNum:            IPMSeqNum;
  576.         exactMatch:                BOOLEAN;
  577.         padByte:                SInt8;
  578.         reserved:                LONGINT;
  579.     END;
  580.  
  581.     IPMOpenHFSMsgPBPtr = ^IPMOpenHFSMsgPB;
  582.     IPMOpenHFSMsgPB = RECORD
  583.         qLink:                    Ptr;
  584.         reservedH1:                LONGINT;
  585.         reservedH2:                LONGINT;
  586.         ioCompletion:            IPMIOCompletionUPP;
  587.         ioResult:                OSErr;
  588.         saveA5:                    LONGINT;
  589.         reqCode:                INTEGER;
  590.         hfsPath:                FSSpecPtr;
  591.         filler:                    LONGINT;
  592.         newMsgRef:                IPMMsgRef;
  593.         filler2:                LONGINT;
  594.         filler3:                SInt8;
  595.         filler4:                BOOLEAN;
  596.         reserved:                LONGINT;
  597.     END;
  598.  
  599.     IPMOpenBlockAsMsgPBPtr = ^IPMOpenBlockAsMsgPB;
  600.     IPMOpenBlockAsMsgPB = RECORD
  601.         qLink:                    Ptr;
  602.         reservedH1:                LONGINT;
  603.         reservedH2:                LONGINT;
  604.         ioCompletion:            IPMIOCompletionUPP;
  605.         ioResult:                OSErr;
  606.         saveA5:                    LONGINT;
  607.         reqCode:                INTEGER;
  608.         msgRef:                    IPMMsgRef;
  609.         filler:                    LONGINT;
  610.         newMsgRef:                IPMMsgRef;
  611.         filler2:                ARRAY [0..6] OF INTEGER;
  612.         blockIndex:                INTEGER;
  613.     END;
  614.  
  615.     IPMCloseMsgPBPtr = ^IPMCloseMsgPB;
  616.     IPMCloseMsgPB = RECORD
  617.         qLink:                    Ptr;
  618.         reservedH1:                LONGINT;
  619.         reservedH2:                LONGINT;
  620.         ioCompletion:            IPMIOCompletionUPP;
  621.         ioResult:                OSErr;
  622.         saveA5:                    LONGINT;
  623.         reqCode:                INTEGER;
  624.         msgRef:                    IPMMsgRef;
  625.         deleteMsg:                BOOLEAN;
  626.         filler1:                BOOLEAN;
  627.     END;
  628.  
  629.     IPMGetMsgInfoPBPtr = ^IPMGetMsgInfoPB;
  630.     IPMGetMsgInfoPB = RECORD
  631.         qLink:                    Ptr;
  632.         reservedH1:                LONGINT;
  633.         reservedH2:                LONGINT;
  634.         ioCompletion:            IPMIOCompletionUPP;
  635.         ioResult:                OSErr;
  636.         saveA5:                    LONGINT;
  637.         reqCode:                INTEGER;
  638.         msgRef:                    IPMMsgRef;
  639.         info:                    IPMMsgInfoPtr;
  640.     END;
  641.  
  642.     IPMReadHeaderPBPtr = ^IPMReadHeaderPB;
  643.     IPMReadHeaderPB = RECORD
  644.         qLink:                    Ptr;
  645.         reservedH1:                LONGINT;
  646.         reservedH2:                LONGINT;
  647.         ioCompletion:            IPMIOCompletionUPP;
  648.         ioResult:                OSErr;
  649.         saveA5:                    LONGINT;
  650.         reqCode:                INTEGER;
  651.         msgRef:                    IPMMsgRef;
  652.         fieldSelector:            INTEGER;
  653.         offset:                    LONGINT;
  654.         count:                    LONGINT;
  655.         buffer:                    Ptr;
  656.         actualCount:            LONGINT;
  657.         filler:                    INTEGER;
  658.         remaining:                LONGINT;
  659.     END;
  660.  
  661.     IPMReadRecipientPBPtr = ^IPMReadRecipientPB;
  662.     IPMReadRecipientPB = RECORD
  663.         qLink:                    Ptr;
  664.         reservedH1:                LONGINT;
  665.         reservedH2:                LONGINT;
  666.         ioCompletion:            IPMIOCompletionUPP;
  667.         ioResult:                OSErr;
  668.         saveA5:                    LONGINT;
  669.         reqCode:                INTEGER;
  670.         msgRef:                    IPMMsgRef;
  671.         rcptIndex:                INTEGER;
  672.         offset:                    LONGINT;
  673.         count:                    LONGINT;
  674.         buffer:                    Ptr;
  675.         actualCount:            LONGINT;
  676.         reserved:                INTEGER;                                {  must be zero  }
  677.         remaining:                LONGINT;
  678.         originalIndex:            INTEGER;
  679.         recipientOffsetFlags:    SInt8;
  680.         filler1:                BOOLEAN;
  681.     END;
  682.  
  683. {
  684. replyQueue works like recipient. [can no longer read it via ReadHeader]
  685. OriginalIndex is meaningless, rcptFlags are used seperately and there are
  686. currently none defined.
  687. }
  688.     IPMReadReplyQueuePB                    = IPMReadRecipientPB;
  689.     IPMReadReplyQueuePBPtr                 = ^IPMReadReplyQueuePB;
  690.     IPMGetBlkIndexPBPtr = ^IPMGetBlkIndexPB;
  691.     IPMGetBlkIndexPB = RECORD
  692.         qLink:                    Ptr;
  693.         reservedH1:                LONGINT;
  694.         reservedH2:                LONGINT;
  695.         ioCompletion:            IPMIOCompletionUPP;
  696.         ioResult:                OSErr;
  697.         saveA5:                    LONGINT;
  698.         reqCode:                INTEGER;
  699.         msgRef:                    IPMMsgRef;
  700.         blockType:                IPMBlockType;
  701.         index:                    INTEGER;
  702.         startingFrom:            INTEGER;
  703.         actualBlockType:        IPMBlockType;
  704.         actualBlockIndex:        INTEGER;
  705.     END;
  706.  
  707.     IPMReadMsgPBPtr = ^IPMReadMsgPB;
  708.     IPMReadMsgPB = RECORD
  709.         qLink:                    Ptr;
  710.         reservedH1:                LONGINT;
  711.         reservedH2:                LONGINT;
  712.         ioCompletion:            IPMIOCompletionUPP;
  713.         ioResult:                OSErr;
  714.         saveA5:                    LONGINT;
  715.         reqCode:                INTEGER;
  716.         msgRef:                    IPMMsgRef;
  717.         mode:                    IPMAccessMode;
  718.         offset:                    LONGINT;
  719.         count:                    LONGINT;
  720.         buffer:                    Ptr;
  721.         actualCount:            LONGINT;
  722.         blockIndex:                INTEGER;
  723.         remaining:                LONGINT;
  724.     END;
  725.  
  726.     IPMVerifySignaturePBPtr = ^IPMVerifySignaturePB;
  727.     IPMVerifySignaturePB = RECORD
  728.         qLink:                    Ptr;
  729.         reservedH1:                LONGINT;
  730.         reservedH2:                LONGINT;
  731.         ioCompletion:            IPMIOCompletionUPP;
  732.         ioResult:                OSErr;
  733.         saveA5:                    LONGINT;
  734.         reqCode:                INTEGER;
  735.         msgRef:                    IPMMsgRef;
  736.         signatureContext:        SIGContextPtr;
  737.     END;
  738.  
  739.     IPMNewMsgPBPtr = ^IPMNewMsgPB;
  740.     IPMNewMsgPB = RECORD
  741.         qLink:                    Ptr;
  742.         reservedH1:                LONGINT;
  743.         reservedH2:                LONGINT;
  744.         ioCompletion:            IPMIOCompletionUPP;
  745.         ioResult:                OSErr;
  746.         saveA5:                    LONGINT;
  747.         reqCode:                INTEGER;
  748.         filler:                    LONGINT;
  749.         recipient:                OCERecipientPtr;
  750.         replyQueue:                OCERecipientPtr;
  751.         procHint:                StringPtr;
  752.         filler2:                INTEGER;
  753.         msgType:                IPMMsgTypePtr;
  754.         refCon:                    LONGINT;
  755.         newMsgRef:                IPMMsgRef;
  756.         filler3:                INTEGER;
  757.         filler4:                LONGINT;
  758.         identity:                AuthIdentity;
  759.         sender:                    IPMSenderPtr;
  760.         internalUse:            LONGINT;
  761.         internalUse2:            LONGINT;
  762.     END;
  763.  
  764.     IPMNewHFSMsgPBPtr = ^IPMNewHFSMsgPB;
  765.     IPMNewHFSMsgPB = RECORD
  766.         qLink:                    Ptr;
  767.         reservedH1:                LONGINT;
  768.         reservedH2:                LONGINT;
  769.         ioCompletion:            IPMIOCompletionUPP;
  770.         ioResult:                OSErr;
  771.         saveA5:                    LONGINT;
  772.         reqCode:                INTEGER;
  773.         hfsPath:                FSSpecPtr;
  774.         recipient:                OCERecipientPtr;
  775.         replyQueue:                OCERecipientPtr;
  776.         procHint:                StringPtr;
  777.         filler2:                INTEGER;
  778.         msgType:                IPMMsgTypePtr;
  779.         refCon:                    LONGINT;
  780.         newMsgRef:                IPMMsgRef;
  781.         filler3:                INTEGER;
  782.         filler4:                LONGINT;
  783.         identity:                AuthIdentity;
  784.         sender:                    IPMSenderPtr;
  785.         internalUse:            LONGINT;
  786.         internalUse2:            LONGINT;
  787.     END;
  788.  
  789.     IPMNestMsgPBPtr = ^IPMNestMsgPB;
  790.     IPMNestMsgPB = RECORD
  791.         qLink:                    Ptr;
  792.         reservedH1:                LONGINT;
  793.         reservedH2:                LONGINT;
  794.         ioCompletion:            IPMIOCompletionUPP;
  795.         ioResult:                OSErr;
  796.         saveA5:                    LONGINT;
  797.         reqCode:                INTEGER;
  798.         msgRef:                    IPMMsgRef;
  799.         filler:                    ARRAY [0..8] OF INTEGER;
  800.         refCon:                    LONGINT;
  801.         msgToNest:                IPMMsgRef;
  802.         filler2:                INTEGER;
  803.         startingOffset:            LONGINT;
  804.     END;
  805.  
  806.     IPMNewNestedMsgBlockPBPtr = ^IPMNewNestedMsgBlockPB;
  807.     IPMNewNestedMsgBlockPB = RECORD
  808.         qLink:                    Ptr;
  809.         reservedH1:                LONGINT;
  810.         reservedH2:                LONGINT;
  811.         ioCompletion:            IPMIOCompletionUPP;
  812.         ioResult:                OSErr;
  813.         saveA5:                    LONGINT;
  814.         reqCode:                INTEGER;
  815.         msgRef:                    IPMMsgRef;
  816.         recipient:                OCERecipientPtr;
  817.         replyQueue:                OCERecipientPtr;
  818.         procHint:                StringPtr;
  819.         filler1:                INTEGER;
  820.         msgType:                IPMMsgTypePtr;
  821.         refCon:                    LONGINT;
  822.         newMsgRef:                IPMMsgRef;
  823.         filler2:                INTEGER;
  824.         startingOffset:            LONGINT;
  825.         identity:                AuthIdentity;
  826.         sender:                    IPMSenderPtr;
  827.         internalUse:            LONGINT;
  828.         internalUse2:            LONGINT;
  829.     END;
  830.  
  831.     IPMEndMsgPBPtr = ^IPMEndMsgPB;
  832.     IPMEndMsgPB = RECORD
  833.         qLink:                    Ptr;
  834.         reservedH1:                LONGINT;
  835.         reservedH2:                LONGINT;
  836.         ioCompletion:            IPMIOCompletionUPP;
  837.         ioResult:                OSErr;
  838.         saveA5:                    LONGINT;
  839.         reqCode:                INTEGER;
  840.         msgRef:                    IPMMsgRef;
  841.         msgID:                    IPMMsgID;
  842.         msgTitle:                RStringPtr;
  843.         deliveryNotification:    SInt8;
  844.         priority:                SInt8;
  845.         cancel:                    BOOLEAN;
  846.         padByte:                SInt8;
  847.         reserved:                LONGINT;
  848.         signature:                SIGSignaturePtr;
  849.         signatureSize:            Size;
  850.         signatureContext:        SIGContextPtr;
  851.                                                                         {  family this msg belongs (e.g. mail) use kIPMFamilyUnspecified by default  }
  852.         family:                    OSType;
  853.     END;
  854.  
  855.     IPMAddRecipientPBPtr = ^IPMAddRecipientPB;
  856.     IPMAddRecipientPB = RECORD
  857.         qLink:                    Ptr;
  858.         reservedH1:                LONGINT;
  859.         reservedH2:                LONGINT;
  860.         ioCompletion:            IPMIOCompletionUPP;
  861.         ioResult:                OSErr;
  862.         saveA5:                    LONGINT;
  863.         reqCode:                INTEGER;
  864.         msgRef:                    IPMMsgRef;
  865.         recipient:                OCERecipientPtr;
  866.         reserved:                LONGINT;
  867.     END;
  868.  
  869.     IPMAddReplyQueuePBPtr = ^IPMAddReplyQueuePB;
  870.     IPMAddReplyQueuePB = RECORD
  871.         qLink:                    Ptr;
  872.         reservedH1:                LONGINT;
  873.         reservedH2:                LONGINT;
  874.         ioCompletion:            IPMIOCompletionUPP;
  875.         ioResult:                OSErr;
  876.         saveA5:                    LONGINT;
  877.         reqCode:                INTEGER;
  878.         msgRef:                    IPMMsgRef;
  879.         filler:                    LONGINT;
  880.         replyQueue:                OCERecipientPtr;
  881.     END;
  882.  
  883.     IPMNewBlockPBPtr = ^IPMNewBlockPB;
  884.     IPMNewBlockPB = RECORD
  885.         qLink:                    Ptr;
  886.         reservedH1:                LONGINT;
  887.         reservedH2:                LONGINT;
  888.         ioCompletion:            IPMIOCompletionUPP;
  889.         ioResult:                OSErr;
  890.         saveA5:                    LONGINT;
  891.         reqCode:                INTEGER;
  892.         msgRef:                    IPMMsgRef;
  893.         blockType:                IPMBlockType;
  894.         filler:                    ARRAY [0..4] OF INTEGER;
  895.         refCon:                    LONGINT;
  896.         filler2:                ARRAY [0..2] OF INTEGER;
  897.         startingOffset:            LONGINT;
  898.     END;
  899.  
  900.     IPMWriteMsgPBPtr = ^IPMWriteMsgPB;
  901.     IPMWriteMsgPB = RECORD
  902.         qLink:                    Ptr;
  903.         reservedH1:                LONGINT;
  904.         reservedH2:                LONGINT;
  905.         ioCompletion:            IPMIOCompletionUPP;
  906.         ioResult:                OSErr;
  907.         saveA5:                    LONGINT;
  908.         reqCode:                INTEGER;
  909.         msgRef:                    IPMMsgRef;
  910.         mode:                    IPMAccessMode;
  911.         offset:                    LONGINT;
  912.         count:                    LONGINT;
  913.         buffer:                    Ptr;
  914.         actualCount:            LONGINT;
  915.         currentBlock:            BOOLEAN;
  916.         filler1:                BOOLEAN;
  917.     END;
  918.  
  919.     IPMParamBlock = RECORD
  920.         CASE INTEGER OF
  921.         0: (
  922.             qLink:                Ptr;
  923.             reservedH1:            LONGINT;
  924.             reservedH2:            LONGINT;
  925.             ioCompletion:        IPMIOCompletionUPP;
  926.             ioResult:            OSErr;
  927.             saveA5:                LONGINT;
  928.             reqCode:            INTEGER;
  929.            );
  930.         1: (
  931.             openContextPB:        IPMOpenContextPB;
  932.             );
  933.         2: (
  934.             closeContextPB:        IPMCloseContextPB;
  935.             );
  936.         3: (
  937.             createQueuePB:        IPMCreateQueuePB;
  938.             );
  939.         4: (
  940.             deleteQueuePB:        IPMDeleteQueuePB;
  941.             );
  942.         5: (
  943.             openQueuePB:        IPMOpenQueuePB;
  944.             );
  945.         6: (
  946.             closeQueuePB:        IPMCloseQueuePB;
  947.             );
  948.         7: (
  949.             enumerateQueuePB:    IPMEnumerateQueuePB;
  950.             );
  951.         8: (
  952.             changeQueueFilterPB: IPMChangeQueueFilterPB;
  953.             );
  954.         9: (
  955.             deleteMsgRangePB:    IPMDeleteMsgRangePB;
  956.             );
  957.         10: (
  958.             openMsgPB:            IPMOpenMsgPB;
  959.             );
  960.         11: (
  961.             openHFSMsgPB:        IPMOpenHFSMsgPB;
  962.             );
  963.         12: (
  964.             openBlockAsMsgPB:    IPMOpenBlockAsMsgPB;
  965.             );
  966.         13: (
  967.             closeMsgPB:            IPMCloseMsgPB;
  968.             );
  969.         14: (
  970.             getMsgInfoPB:        IPMGetMsgInfoPB;
  971.             );
  972.         15: (
  973.             readHeaderPB:        IPMReadHeaderPB;
  974.             );
  975.         16: (
  976.             readRecipientPB:    IPMReadRecipientPB;
  977.             );
  978.         17: (
  979.             readReplyQueuePB:    IPMReadReplyQueuePB;
  980.             );
  981.         18: (
  982.             getBlkIndexPB:        IPMGetBlkIndexPB;
  983.             );
  984.         19: (
  985.             readMsgPB:            IPMReadMsgPB;
  986.             );
  987.         20: (
  988.             verifySignaturePB:    IPMVerifySignaturePB;
  989.             );
  990.         21: (
  991.             newMsgPB:            IPMNewMsgPB;
  992.             );
  993.         22: (
  994.             newHFSMsgPB:        IPMNewHFSMsgPB;
  995.             );
  996.         23: (
  997.             nestMsgPB:            IPMNestMsgPB;
  998.             );
  999.         24: (
  1000.             newNestedMsgBlockPB: IPMNewNestedMsgBlockPB;
  1001.             );
  1002.         25: (
  1003.             endMsgPB:            IPMEndMsgPB;
  1004.             );
  1005.         26: (
  1006.             addRecipientPB:        IPMAddRecipientPB;
  1007.             );
  1008.         27: (
  1009.             addReplyQueuePB:    IPMAddReplyQueuePB;
  1010.             );
  1011.         28: (
  1012.             newBlockPB:            IPMNewBlockPB;
  1013.             );
  1014.         29: (
  1015.             writeMsgPB:            IPMWriteMsgPB;
  1016.             );
  1017.     END;
  1018.  
  1019.  
  1020. CONST
  1021.     uppIPMIOCompletionProcInfo = $00009802;
  1022.  
  1023. PROCEDURE CallIPMIOCompletionProc(paramBlock: IPMParamBlockPtr; userRoutine: IPMIOCompletionUPP);
  1024.     {$IFC NOT GENERATINGCFM}
  1025.     {To be implemented:  Glue to move parameters into registers.}
  1026.     {$ENDC}
  1027.  
  1028. FUNCTION NewIPMIOCompletionProc(userRoutine: IPMIOCompletionProcPtr): IPMIOCompletionUPP;
  1029.     {$IFC NOT GENERATINGCFM }
  1030.     INLINE $2E9F;
  1031.     {$ENDC}
  1032. FUNCTION IPMOpenContext(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1033.     {$IFC NOT GENERATINGCFM}
  1034.     INLINE $3F3C, $0400, $AA5E;
  1035.     {$ENDC}
  1036. FUNCTION IPMCloseContext(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1037.     {$IFC NOT GENERATINGCFM}
  1038.     INLINE $3F3C, $0401, $AA5E;
  1039.     {$ENDC}
  1040. FUNCTION IPMNewMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1041.     {$IFC NOT GENERATINGCFM}
  1042.     INLINE $3F3C, $0402, $AA5E;
  1043.     {$ENDC}
  1044. FUNCTION IPMNewBlock(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1045.     {$IFC NOT GENERATINGCFM}
  1046.     INLINE $3F3C, $0404, $AA5E;
  1047.     {$ENDC}
  1048. FUNCTION IPMNewNestedMsgBlock(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1049.     {$IFC NOT GENERATINGCFM}
  1050.     INLINE $3F3C, $0405, $AA5E;
  1051.     {$ENDC}
  1052. FUNCTION IPMNestMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1053.     {$IFC NOT GENERATINGCFM}
  1054.     INLINE $3F3C, $0406, $AA5E;
  1055.     {$ENDC}
  1056. FUNCTION IPMWriteMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1057.     {$IFC NOT GENERATINGCFM}
  1058.     INLINE $3F3C, $0407, $AA5E;
  1059.     {$ENDC}
  1060. FUNCTION IPMEndMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1061.     {$IFC NOT GENERATINGCFM}
  1062.     INLINE $3F3C, $0408, $AA5E;
  1063.     {$ENDC}
  1064. FUNCTION IPMOpenQueue(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1065.     {$IFC NOT GENERATINGCFM}
  1066.     INLINE $3F3C, $0409, $AA5E;
  1067.     {$ENDC}
  1068. FUNCTION IPMCloseQueue(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1069.     {$IFC NOT GENERATINGCFM}
  1070.     INLINE $3F3C, $040A, $AA5E;
  1071.     {$ENDC}
  1072. {  Always synchronous  }
  1073. FUNCTION IPMVerifySignature(paramBlock: IPMParamBlockPtr): OSErr;
  1074.     {$IFC NOT GENERATINGCFM}
  1075.     INLINE $7000, $1F00, $3F3C, $0422, $AA5E;
  1076.     {$ENDC}
  1077. FUNCTION IPMOpenMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1078.     {$IFC NOT GENERATINGCFM}
  1079.     INLINE $3F3C, $040B, $AA5E;
  1080.     {$ENDC}
  1081. FUNCTION IPMCloseMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1082.     {$IFC NOT GENERATINGCFM}
  1083.     INLINE $3F3C, $040C, $AA5E;
  1084.     {$ENDC}
  1085. FUNCTION IPMReadMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1086.     {$IFC NOT GENERATINGCFM}
  1087.     INLINE $3F3C, $040D, $AA5E;
  1088.     {$ENDC}
  1089. FUNCTION IPMReadHeader(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1090.     {$IFC NOT GENERATINGCFM}
  1091.     INLINE $3F3C, $040E, $AA5E;
  1092.     {$ENDC}
  1093. FUNCTION IPMOpenBlockAsMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1094.     {$IFC NOT GENERATINGCFM}
  1095.     INLINE $3F3C, $040F, $AA5E;
  1096.     {$ENDC}
  1097. FUNCTION IPMNewHFSMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1098.     {$IFC NOT GENERATINGCFM}
  1099.     INLINE $3F3C, $041E, $AA5E;
  1100.     {$ENDC}
  1101. FUNCTION IPMReadRecipient(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1102.     {$IFC NOT GENERATINGCFM}
  1103.     INLINE $3F3C, $0410, $AA5E;
  1104.     {$ENDC}
  1105. FUNCTION IPMReadReplyQueue(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1106.     {$IFC NOT GENERATINGCFM}
  1107.     INLINE $3F3C, $0421, $AA5E;
  1108.     {$ENDC}
  1109. FUNCTION IPMCreateQueue(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1110.     {$IFC NOT GENERATINGCFM}
  1111.     INLINE $3F3C, $0411, $AA5E;
  1112.     {$ENDC}
  1113. FUNCTION IPMDeleteQueue(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1114.     {$IFC NOT GENERATINGCFM}
  1115.     INLINE $3F3C, $0412, $AA5E;
  1116.     {$ENDC}
  1117. FUNCTION IPMEnumerateQueue(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1118.     {$IFC NOT GENERATINGCFM}
  1119.     INLINE $3F3C, $0413, $AA5E;
  1120.     {$ENDC}
  1121. FUNCTION IPMChangeQueueFilter(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1122.     {$IFC NOT GENERATINGCFM}
  1123.     INLINE $3F3C, $0414, $AA5E;
  1124.     {$ENDC}
  1125. FUNCTION IPMDeleteMsgRange(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1126.     {$IFC NOT GENERATINGCFM}
  1127.     INLINE $3F3C, $0415, $AA5E;
  1128.     {$ENDC}
  1129. FUNCTION IPMAddRecipient(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1130.     {$IFC NOT GENERATINGCFM}
  1131.     INLINE $3F3C, $0403, $AA5E;
  1132.     {$ENDC}
  1133. FUNCTION IPMAddReplyQueue(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1134.     {$IFC NOT GENERATINGCFM}
  1135.     INLINE $3F3C, $041D, $AA5E;
  1136.     {$ENDC}
  1137. FUNCTION IPMOpenHFSMsg(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1138.     {$IFC NOT GENERATINGCFM}
  1139.     INLINE $3F3C, $0417, $AA5E;
  1140.     {$ENDC}
  1141. FUNCTION IPMGetBlkIndex(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1142.     {$IFC NOT GENERATINGCFM}
  1143.     INLINE $3F3C, $0418, $AA5E;
  1144.     {$ENDC}
  1145. FUNCTION IPMGetMsgInfo(paramBlock: IPMParamBlockPtr; async: BOOLEAN): OSErr;
  1146.     {$IFC NOT GENERATINGCFM}
  1147.     INLINE $3F3C, $0419, $AA5E;
  1148.     {$ENDC}
  1149. {$ENDC}
  1150. {$ALIGN RESET}
  1151. {$POP}
  1152.  
  1153. {$SETC UsingIncludes := OCEMessagingIncludes}
  1154.  
  1155. {$ENDC} {__OCEMESSAGING__}
  1156.  
  1157. {$IFC NOT UsingIncludes}
  1158.  END.
  1159. {$ENDC}
  1160.